#include "RegistroVariableNewsDataCategoria.h"

RegistroVariableNewsDataCategoria::RegistroVariableNewsDataCategoria()
{
        InitializeRegistro();
}

RegistroVariableNewsDataCategoria::~RegistroVariableNewsDataCategoria()
{
        InitializeRegistro();
}

void RegistroVariableNewsDataCategoria::getListaPositivos(ListaCategorias &listaPositivos)
{
        listaPositivos.clear();

        ListaCategorias::iterator iteradorLista;

        for (iteradorLista = this->listaPositivos.begin();
             iteradorLista != this->listaPositivos.end();
             iteradorLista++)
        {
                listaPositivos.push_back(*iteradorLista);
        }
}

void RegistroVariableNewsDataCategoria::getListaNegativos(ListaCategorias &listaNegativos)
{
        listaNegativos.clear();

        ListaCategorias::iterator iteradorLista;

        for (iteradorLista = this->listaNegativos.begin();
             iteradorLista != this->listaNegativos.end();
             iteradorLista++)
        {
                listaNegativos.push_back(*iteradorLista);
        }
}

TCBooleano RegistroVariableNewsDataCategoria::getEstado()
{
        return this->estado;
}

void RegistroVariableNewsDataCategoria::setListaPositivos(ListaCategorias &value)
{
        this->listaPositivos.clear();

        ListaCategorias::iterator iteradorLista;

        for (iteradorLista = value.begin();
             iteradorLista != value.end();
             iteradorLista++)
        {
                this->listaPositivos.push_back(*iteradorLista);
        }

        this->cantidadPositivos = this->listaPositivos.size();
}

void RegistroVariableNewsDataCategoria::setListaNegativos(ListaCategorias &value)
{
        this->listaNegativos.clear();

        ListaCategorias::iterator iteradorLista;

        for (iteradorLista = value.begin();
             iteradorLista != value.end();
             iteradorLista++)
        {
                this->listaNegativos.push_back(*iteradorLista);
        }
}

void RegistroVariableNewsDataCategoria::setEstado(TCBooleano value)
{
        this->estado = value;
}

bool RegistroVariableNewsDataCategoria::AgregarAListaPositivos(TCId idCategoria)
{
        //si fuera un set podria ver si ya existe y devolver true o false si
        //inserto algo o no para optimizar y no escribir a disco
        //ver si no hace falta actualizar la lista de negativos
        this->listaPositivos.push_back(idCategoria);
        this->cantidadPositivos++;
        return true;
}

bool RegistroVariableNewsDataCategoria::AgregarAListaNegativos(TCId idCategoria)
{
        //si fuera un set podria ver si ya existe y devolver true o false si
        //inserto algo o no para optimizar y no escribir a disco
        //ver si no hace falta actualizar la lista de negativos
        this->listaNegativos.push_back(idCategoria);
        return true;
}

ListaCategorias* RegistroVariableNewsDataCategoria::getListaPositivosReferencia()
{
        return &this->listaPositivos;
}

ListaCategorias* RegistroVariableNewsDataCategoria::getListaNegativosReferencia()
{
        return &this->listaNegativos;
}

void RegistroVariableNewsDataCategoria::InitializeRegistro()
{
        this->estado = true;
        this->listaPositivos.clear();
        this->listaNegativos.clear();
        this->cantidadPositivos = 0;
}

void RegistroVariableNewsDataCategoria::purgarCategorias(ConjuntoCategorias& categoriasVivas)
{
        ListaCategorias::iterator iteradorListas;
        ConjuntoCategorias::iterator iteradorConjunto;

        ConjuntoCategorias elementosABorrar;

        for (iteradorListas = listaPositivos.begin();
             iteradorListas != listaPositivos.end();
             iteradorListas++)
        {
                if (categoriasVivas.count(*iteradorListas) == 0)
                {
                        elementosABorrar.insert(*iteradorListas);
                }
        }

        for (iteradorConjunto = elementosABorrar.begin();
             iteradorConjunto != elementosABorrar.end();
             iteradorConjunto++)
        {
                listaPositivos.remove(*iteradorConjunto);
                this->cantidadPositivos--;
        }

        elementosABorrar.clear();

        for (iteradorListas = listaNegativos.begin();
             iteradorListas != listaNegativos.end();
             iteradorListas++)
        {
                if (categoriasVivas.count(*iteradorListas) == 0)
                {
                        elementosABorrar.insert(*iteradorListas);
                }
        }

        for (iteradorConjunto = elementosABorrar.begin();
             iteradorConjunto != elementosABorrar.end();
             iteradorConjunto++)
        {
                listaNegativos.remove(*iteradorConjunto);
        }

        elementosABorrar.clear();                                
}

void RegistroVariableNewsDataCategoria::fillBuffer()
{
        this->setTamanioBuffer(sizeof(this->estado) +
                (sizeof(this->cantidadPositivos)) + 
                (sizeof(TCId) * this->listaPositivos.size()) +
                (sizeof(TCId) * this->listaNegativos.size()));
                
        this->crearBuffer();
        
        this->putIntoBuffer(&this->estado, sizeof(this->estado));
        this->putIntoBuffer(&this->cantidadPositivos, sizeof(this->cantidadPositivos));

        TCId elemento;
        ListaCategorias::iterator iteradorLista;

        for (iteradorLista = this->listaPositivos.begin();
             iteradorLista != this->listaPositivos.end();
             iteradorLista++)
        {
                elemento = *iteradorLista;
                this->putIntoBuffer(&elemento, sizeof(elemento));                                               
        }

        for (iteradorLista = this->listaNegativos.begin();
             iteradorLista != this->listaNegativos.end();
             iteradorLista++)
        {
                elemento = *iteradorLista;
                this->putIntoBuffer(&elemento, sizeof(elemento));                                               
        }
        
}

void RegistroVariableNewsDataCategoria::readFromBuffer()
{
        this->getFromBuffer(&this->estado, sizeof(this->estado));
        this->getFromBuffer(&this->cantidadPositivos, sizeof(this->cantidadPositivos));

        TCId elemento;

        for (int i = 0; i < this->cantidadPositivos; i++)
        {
                this->getFromBuffer(&elemento, sizeof(elemento));
                this->listaPositivos.push_back(elemento);
        }

        int cantidadPendiente = 0;
        cantidadPendiente = (this->bytesLeft() / sizeof(TCId));

        for (int j = 0; j < cantidadPendiente; j++)
        {
                this->getFromBuffer(&elemento, sizeof(elemento));
                this->listaNegativos.push_back(elemento);
        }
}


